JavaScript സ്വകാര്യ ഫീൽഡുകൾ: യഥാർത്ഥ ക്ലാസ് എൻക്യാപ്‌സുലേഷനും ഡാറ്റാ ഒളിപ്പിക്കലും ആഴത്തിലുള്ള പഠനം

സോഫ്റ്റ്‌വെയർ ഡെവലപ്‌മെൻ്റ് ലോകത്ത്, കരുത്തുറ്റതും പരിപാലിക്കാൻ എളുപ്പമുള്ളതും സുരക്ഷിതവുമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നത് വളരെ പ്രധാനമാണ്. ഈ ലക്ഷ്യം നേടുന്നതിനുള്ള പ്രധാന ഘടകമാണ് എൻക്യാപ്‌സുലേഷൻ. ഡാറ്റയെ (properties) ആ ഡാറ്റയിൽ പ്രവർത്തിക്കുന്ന രീതികളുമായി ബന്ധിപ്പിച്ച്, ഒബ്‌ജക്റ്റിൻ്റെ ഇ অভ্যন্তরীণ അവസ്ഥയിലേക്ക് നേരിട്ടുള്ള പ്രവേശനം നിയന്ത്രിക്കുന്നതിനെയാണ് എൻക്യാപ്‌സുലേഷൻ എന്ന് പറയുന്നത്. വർഷങ്ങളായി, JavaScript ഡെവലപ്പർമാർക്ക് സ്വകാര്യ ക്ലാസ് അംഗങ്ങളെ നിർമ്മിക്കുന്നതിന് ഒരു ഭാഷാപരമായ മാർഗ്ഗം ആവശ്യമായിരുന്നു. ചില രീതികളും പാറ്റേണുകളും ഇതിന് ബദലായി ഉപയോഗിച്ചെങ്കിലും അതൊന്നും പൂർണ്ണമായിരുന്നില്ല.

ആ കാലഘട്ടം കഴിഞ്ഞു. ECMAScript 2022 സ്പെസിഫിക്കേഷനിൽ സ്വകാര്യ ക്ലാസ് ഫീൽഡുകൾ ഉൾപ്പെടുത്തിയതോടെ, ഡാറ്റാ ഒളിപ്പിക്കുന്നതിനുള്ള ലളിതവും ശക്തവുമായ ഒരു സിന്റാക്സ് JavaScript-ൽ ഉണ്ട്. ഒരു ഹാഷ് ചിഹ്നം (#) ഉപയോഗിച്ച് ഇത് സൂചിപ്പിക്കുന്നു. ഇത് നമ്മളുടെ ക്ലാസ്സുകൾ രൂപകൽപ്പന ചെയ്യുന്നതിലും ക്രമീകരിക്കുന്നതിലും മാറ്റം വരുത്തുന്നു, അതുപോലെ Java, C#, Python പോലുള്ള ഭാഷകളുമായി JavaScript-ൻ്റെ OOP ശേഷികളെ കൂടുതൽ ചേർക്കുന്നു.

ഈ ലേഖനം JavaScript സ്വകാര്യ ഫീൽഡുകളിലേക്ക് ആഴത്തിലുള്ള ഒരു പഠനം നൽകുന്നു. ഇതിൻ്റെ ആവശ്യകതയുടെ കാരണം, സ്വകാര്യ ഫീൽഡുകളുടെയും രീതികളുടെയും സിന്റാക്സ്, പ്രധാനപ്പെട്ട നേട്ടങ്ങൾ, കൂടാതെ പ്രായോഗികമായ സാഹചര്യങ്ങൾ എന്നിവ ഈ ലേഖനത്തിൽ പറയുന്നു. നിങ്ങൾ ഒരു ഡെവലപ്പർ ആണെങ്കിലും JavaScript ക്ലാസുകൾ പഠിക്കാൻ തുടങ്ങുന്ന ഒരാളാണെങ്കിലും, ഈ ആധുനിക ഫീച്ചറുകളെക്കുറിച്ച് മനസിലാക്കുന്നത് പ്രൊഫഷണൽ-ഗ്രേഡ് കോഡിംഗ് എഴുതുന്നതിന് അത്യാവശ്യമാണ്.

പഴയ രീതി: JavaScript-ൽ സ്വകാര്യതയുടെ അനുകരണം

# സിന്റാക്സിൻ്റെ പ്രാധാന്യം പൂർണ്ണമായി മനസ്സിലാക്കാൻ, JavaScript ഡെവലപ്പർമാർ സ്വകാര്യത നേടാൻ ശ്രമിച്ചതിൻ്റെ ചരിത്രം മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്. ഈ രീതികൾ ബുദ്ധിപരമായിരുന്നു, പക്ഷേ പൂർണ്ണമായ എൻക്യാപ്‌സുലേഷൻ നൽകുന്നതിൽ കുറവായിരുന്നു.

അണ്ടർസ്‌കോർ കൺവെൻഷൻ (_)

ഏറ്റവും സാധാരണവും പഴയതുമായ സമീപനം ഒരു പേരിടൽ രീതിയായിരുന്നു: ഒരു പ്രോപ്പർട്ടിയുടെയോ രീതിയുടെയോ പേരിന് മുന്നിൽ ഒരു അടിവര (_) ചേർക്കുക. ഇത് മറ്റ് ഡെവലപ്പർമാർക്കുള്ള ഒരു സൂചനയായി കണക്കാക്കി: "ഇതൊരു ഇന്റേണൽ പ്രോപ്പർട്ടിയാണ്. ദയവായി ഇത് നേരിട്ട് ഉപയോഗിക്കരുത്."

ഒരു ലളിതമായ `BankAccount` ക്ലാസ് പരിഗണിക്കുക:

            
class BankAccount {
  constructor(ownerName, initialBalance) {
    this.ownerName = ownerName;
    this._balance = initialBalance; // Convention: This is 'private'
  }

  deposit(amount) {
    if (amount > 0) {
      this._balance += amount;
      console.log(`Deposited: ${amount}. New balance: ${this._balance}`);
    }
  }

  // A public getter to access the balance safely
  getBalance() {
    return this._balance;
  }
}

const myAccount = new BankAccount('John Doe', 1000);
console.log(myAccount.getBalance()); // 1000

// The problem: The convention can be ignored
myAccount._balance = -5000; // Direct manipulation is possible!
console.log(myAccount.getBalance()); // -5000 (Invalid state!)

            

              
                Copy
              
            
          

ഇതിലെ പ്രധാന പോരായ്മ എന്തെന്നാൽ അടിവര ഒരു നിർദ്ദേശം മാത്രമാണ്. `_balance` ആക്‌സസ് ചെയ്യുന്നതിൽ നിന്നോ മാറ്റം വരുത്തുന്നതിൽ നിന്നോ ബാഹ്യ കോഡിനെ തടയുന്ന ഒരു മെക്കാനിസവും നിലവിലില്ല. ഇത് ഒബ്‌ജക്റ്റിൻ്റെ അവസ്ഥയെ തകരാറിലാക്കുകയും `deposit` പോലുള്ള രീതിയിലുള്ള വാലിഡേഷൻ ലോജിക്കിനെ മറികടക്കുകയും ചെയ്യും.

ക്ലോഷറുകളും മൊഡ്യൂൾ പാറ്റേണും

ക്ലോഷറുകൾ ഉപയോഗിച്ച് സ്വകാര്യ സ്റ്റേറ്റ് ഉണ്ടാക്കുന്ന രീതിയാണ് ഇതിലൂടെ ഉദ്ദേശിക്കുന്നത്. `class` സിന്റാക്സ് വരുന്നതിനു മുൻപ് ഫാക്ടറി ഫങ്ക്ഷനുകളും മൊഡ്യൂൾ പാറ്റേണുകളും ഉപയോഗിച്ചാണ് ഇത് നടപ്പിലാക്കിയിരുന്നത്.

            
function createBankAccount(ownerName, initialBalance) {
  let balance = initialBalance; // This variable is private due to closure

  return {
    getOwner: () => ownerName,

    getBalance: () => balance, // Publicly exposes the balance value

    deposit: function(amount) {
      if (amount > 0) {
        balance += amount;
        console.log(`Deposited: ${amount}. New balance: ${balance}`);
      }
    },

    withdraw: function(amount) {
      if (amount > 0 && amount <= balance) {
        balance -= amount;
        console.log(`Withdrew: ${amount}. New balance: ${balance}`);
      } else {
        console.log('Insufficient funds or invalid amount.');
      }
    }
  };
}

const myAccount = createBankAccount('Jane Smith', 2000);

console.log(myAccount.getBalance()); // 2000
myAccount.deposit(500); // Deposited: 500. New balance: 2500

// Attempting to access the private variable fails
console.log(myAccount.balance); // undefined
myAccount.balance = 9999; // Creates a new, unrelated property
console.log(myAccount.getBalance()); // 2500 (The internal state is safe!)

            

              
                Copy
              
            
          

ഈ പാറ്റേൺ സ്വകാര്യത നൽകുന്നു. `balance` വേരിയബിൾ `createBankAccount` ഫംഗ്ഷൻ്റെ സ്കോപ്പിൽ മാത്രമേ ഉണ്ടാകൂ, അത് പുറത്ത് നിന്ന് ആക്സസ് ചെയ്യാൻ കഴിയില്ല. എന്നിരുന്നാലും, ഈ സമീപനത്തിന് അതിൻ്റേതായ പോരായ്മകളുണ്ട്: ഇത് കൂടുതൽ വലുതാകാനും, കുറഞ്ഞ മെമ്മറി ഉപയോഗിക്കാനും (ഓരോ ഇൻസ്റ്റൻസിനും അതിൻ്റേതായ രീതികളുടെ കോപ്പി ഉണ്ടാകും), കൂടാതെ ഇൻഹെറിറ്റൻസ് പോലുള്ള ആധുനിക `class` സിന്റാക്സുമായി ഇത് യോജിക്കുന്നില്ല.

യഥാർത്ഥ സ്വകാര്യത അവതരിപ്പിക്കുന്നു: ഹാഷ് # സിന്റാക്സ്

ഹാഷ് (#) പ്രിഫിക്സുള്ള സ്വകാര്യ ക്ലാസ് ഫീൽഡുകൾ ഈ പ്രശ്നങ്ങളെല്ലാം ഇല്ലാതാക്കുന്നു. ഇത് ക്ലാസുകളുടെ ശുദ്ധമായ സിന്റാക്സിനൊപ്പം ക്ലോഷറുകളുടെ ശക്തമായ സ്വകാര്യത നൽകുന്നു. ഇതൊരു കൺവെൻഷനല്ല; ഇതൊരു നിയമമാണ്.

ഒരു സ്വകാര്യ ഫീൽഡ് ക്ലാസ് ബോഡിയുടെ മുകളിൽ ഡിക്ലയർ ചെയ്യണം. ക്ലാസിന് പുറത്ത് നിന്ന് ഒരു സ്വകാര്യ ഫീൽഡ് ആക്സസ് ചെയ്യാൻ ശ്രമിച്ചാൽ, അത് കംപൈൽ സമയത്ത് `SyntaxError`-നോ റൺടൈമിൽ `TypeError`-നോ കാരണമാവുകയും സ്വകാര്യത ലംഘിക്കാൻ സാധിക്കാത്ത അവസ്ഥ ഉണ്ടാക്കുകയും ചെയ്യുന്നു.

പ്രധാന സിന്റാക്സ്: സ്വകാര്യ ഇൻസ്റ്റൻസ് ഫീൽഡുകൾ

ഒരു സ്വകാര്യ ഫീൽഡ് ഉപയോഗിച്ച് നമ്മുടെ `BankAccount` ക്ലാസ് മാറ്റിയെഴുതാം.

            
class BankAccount {
  // 1. Declare the private field
  #balance;

  constructor(ownerName, initialBalance) {
    this.ownerName = ownerName; // Public field
    // 2. Initialize the private field
    if (initialBalance > 0) {
      this.#balance = initialBalance;
    } else {
      throw new Error('Initial balance must be positive.');
    }
  }

  deposit(amount) {
    if (amount > 0) {
      this.#balance += amount;
      console.log(`Deposited: ${amount}.`);
    }
  }

  withdraw(amount) {
    if (amount > 0 && amount <= this.#balance) {
      this.#balance -= amount;
      console.log(`Withdrew: ${amount}.`);
    } else {
      console.error('Withdrawal failed: Invalid amount or insufficient funds.');
    }
  }

  getBalance() {
    // Public method provides controlled access to the private field
    return this.#balance;
  }
}

const myAccount = new BankAccount('Alice', 500);
myAccount.deposit(100);
console.log(myAccount.getBalance()); // 600

// Now, let's try to break it...

try {
  // This will fail. It's not a suggestion; it's a hard rule.
  console.log(myAccount.#balance);
} catch (e) {
  console.error(e); // TypeError: Cannot read private member #balance from an object whose class did not declare it
}

// This doesn't modify the private field. It creates a new, public property.
myAccount['#balance'] = 9999;
console.log(myAccount.getBalance()); // 600 (The internal state remains safe!)

            

              
                Copy
              
            
          

ഇതൊരു ഗെയിം ചേഞ്ചറാണ്. #balance ഫീൽഡ് ശരിക്കും സ്വകാര്യമാണ്. `BankAccount` ക്ലാസ് ബോഡിക്കുള്ളിൽ എഴുതിയ കോഡിന് മാത്രമേ ഇത് ആക്സസ് ചെയ്യാനോ മാറ്റം വരുത്താനോ കഴിയൂ. നമ്മുടെ ഒബ്ജക്റ്റിൻ്റെ സമഗ്രത ഇപ്പോൾ JavaScript എഞ്ചിൻ തന്നെ സംരക്ഷിക്കുന്നു.

സ്വകാര്യ രീതികൾ

# സിന്റാക്സ് രീതികൾക്കും ബാധകമാണ്. ക്ലാസ് നടപ്പിലാക്കുന്നതിൻ്റെ ഭാഗമായുള്ള ഇന്റേണൽ ഹെൽപ്പർ ഫംഗ്ഷനുകൾക്ക് ഇത് ഉപയോഗപ്രദമാണ്, പക്ഷേ അത് അതിൻ്റെ പബ്ലിക് API-യുടെ ഭാഗമായിരിക്കരുത്.

ഫൈനൽ റിപ്പോർട്ട് ഉണ്ടാക്കുന്നതിന് മുൻപ് ചില കോംപ്ലക്സ് ഇന്റേണൽ കാൽക്കുലേഷനുകൾ നടത്തേണ്ട ഒരു `ReportGenerator` ക്ലാസ് സങ്കൽപ്പിക്കുക.

            
class ReportGenerator {
  #data;

  constructor(rawData) {
    this.#data = rawData;
  }

  // Private helper method for internal calculation
  #calculateTotalSales() {
    console.log('Performing complex and secret calculations...');
    return this.#data.reduce((total, item) => total + item.price * item.quantity, 0);
  }

  // Private helper for formatting
  #formatCurrency(amount) {
    // In a real-world scenario, this would use Intl.NumberFormat for global audiences
    return `$${amount.toFixed(2)}`;
  }

  // Public API method
  generateSalesReport() {
    const totalSales = this.#calculateTotalSales(); // Calls the private method
    const formattedTotal = this.#formatCurrency(totalSales); // Calls another private method

    return {
      reportDate: new Date(),
      totalSales: formattedTotal,
      itemCount: this.#data.length
    };
  }
}

const salesData = [
  { price: 10, quantity: 5 },
  { price: 25, quantity: 2 },
  { price: 5, quantity: 20 }
];

const generator = new ReportGenerator(salesData);
const report = generator.generateSalesReport();
console.log(report); // { reportDate: ..., totalSales: '$200.00', itemCount: 3 }

// Attempting to call the private method from outside fails
try {
  generator.#calculateTotalSales();
} catch (e) {
  console.error(e.name, e.message);
}

            

              
                Copy
              
            
          

#calculateTotalSales-ഉം #formatCurrency-ഉം സ്വകാര്യമാക്കുന്നതിലൂടെ, `ReportGenerator` ക്ലാസ് ഉപയോഗിക്കുന്ന കോഡിനെ തകരാറിലാക്കാതെ തന്നെ അവയുടെ രീതി മാറ്റാനോ, പേരുമാറ്റാനോ, അല്ലെങ്കിൽ ഭാവിയിൽ നീക്കം ചെയ്യാനോ സാധിക്കും. `generateSalesReport` രീതി ഉപയോഗിച്ച് മാത്രമേ പബ്ലിക് കോൺട്രാക്ട് നിർവചിക്കാൻ കഴിയൂ.

സ്വകാര്യ സ്റ്റാറ്റിക് ഫീൽഡുകളും രീതികളും

`static` കീവേഡ് `private` സിന്റാക്സുമായി ചേർത്ത് ഉപയോഗിക്കാൻ സാധിക്കും. സ്വകാര്യ സ്റ്റാറ്റിക് മെമ്പർമാർ ക്ലാസിന് സ്വന്തമായിരിക്കും, ക്ലാസിൻ്റെ ഏതെങ്കിലും ഇൻസ്റ്റൻസിന്റേതല്ല.

എല്ലാ ഇൻസ്റ്റൻസുകളിലും പങ്കിടേണ്ട വിവരങ്ങൾ സൂക്ഷിക്കാൻ ഇത് ഉപയോഗപ്രദമാണ്, പക്ഷേ അത് പബ്ലിക് സ്കോപ്പിൽ നിന്ന് മറഞ്ഞിരിക്കണം. ഒരു ക്ലാസ്സിന്റെ എത്ര ഇൻസ്റ്റൻസുകൾ ക്രിയേറ്റ് ചെയ്തു എന്ന് ട്രാക്ക് ചെയ്യുന്നതിനുള്ള ഒരു ഉദാഹരണമാണ്.

            
class DatabaseConnection {
  // Private static field to count instances
  static #instanceCount = 0;

  // Private static method for logging internal events
  static #log(message) {
    console.log(`[DBConnection Internal]: ${message}`);
  }

  constructor(connectionString) {
    this.connectionString = connectionString;
    DatabaseConnection.#instanceCount++;
    DatabaseConnection.#log(`New connection created. Total: ${DatabaseConnection.#instanceCount}`);
  }

  connect() {
    console.log(`Connecting to ${this.connectionString}...`);
  }

  // Public static method to get the count
  static getInstanceCount() {
    return DatabaseConnection.#instanceCount;
  }
}

const conn1 = new DatabaseConnection('server1/db');
const conn2 = new DatabaseConnection('server2/db');

console.log(`Total connections created: ${DatabaseConnection.getInstanceCount()}`); // Total connections created: 2

// Accessing the private static members from outside is impossible
console.log(DatabaseConnection.#instanceCount); // SyntaxError
DatabaseConnection.#log('Trying to log'); // SyntaxError

            

              
                Copy
              
            
          

എന്തുകൊണ്ട് സ്വകാര്യ ഫീൽഡുകൾ ഉപയോഗിക്കണം? പ്രധാന നേട്ടങ്ങൾ

സിന്റാക്സ് കണ്ടുകഴിഞ്ഞ സ്ഥിതിക്ക്, ആധുനിക സോഫ്റ്റ്‌വെയർ ഡെവലപ്‌മെൻ്റിന് ഈ ഫീച്ചർ എത്രത്തോളം പ്രധാനമാണെന്ന് നോക്കാം.

1. യഥാർത്ഥ എൻക്യാപ്‌സുലേഷനും ഡാറ്റാ ഒളിപ്പിക്കലും

ഇതാണ് പ്രധാനപ്പെട്ട നേട്ടം. ഒരു ക്ലാസ്സിൻ്റെ ഇംപ്ലിമെൻ്റേഷനും അതിൻ്റെ പബ്ലിക് ഇൻ്റർഫേസും തമ്മിലുള്ള അതിർവരമ്പ് സ്വകാര്യ ഫീൽഡുകൾ ഉറപ്പാക്കുന്നു. ഒരു ഒബ്ജക്റ്റിൻ്റെ അവസ്ഥ അതിൻ്റെ പബ്ലിക് രീതികളിലൂടെ മാത്രമേ മാറ്റാൻ കഴിയൂ, ഇത് ഒബ്ജക്റ്റ് എല്ലായ്പ്പോഴും സാധുവായ അവസ്ഥയിലായിരിക്കുമെന്ന് ഉറപ്പാക്കുന്നു. ബാഹ്യ കോഡിന് ഒരു ഒബ്ജക്റ്റിൻ്റെ ഇന്റേണൽ ഡാറ്റയിൽ മാറ്റങ്ങൾ വരുത്തുന്നതിൽ നിന്ന് ഇത് തടയുന്നു.

2. കരുത്തുറ്റതും സ്ഥിരതയുള്ളതുമായ API-കൾ ഉണ്ടാക്കുന്നു

മറ്റുള്ളവർക്ക് ഉപയോഗിക്കാനായി നിങ്ങൾ ഒരു ക്ലാസ്സോ മൊഡ്യൂളോ ഉണ്ടാക്കുമ്പോൾ, നിങ്ങൾ ഒരു API ഉണ്ടാക്കുകയാണ് ചെയ്യുന്നത്. ഇന്റേണൽ പ്രോപ്പർട്ടികളും രീതികളും സ്വകാര്യമാക്കുന്നതിലൂടെ, നിങ്ങളുടെ ക്ലാസ്സിൻ്റെ ഏതൊക്കെ ഭാഗങ്ങളാണ് ഉപയോഗിക്കാൻ സുരക്ഷിതമെന്ന് വ്യക്തമായി പറയാൻ സാധിക്കും. ക്ലാസ് ഉപയോഗിക്കുന്ന എല്ലാവരുടെയും കോഡിനെ തകരാറിലാക്കാതെ തന്നെ, പിന്നീട് ഇംപ്ലിമെൻ്റേഷൻ മാറ്റാനോ അല്ലെങ്കിൽ ഒപ്റ്റിമൈസ് ചെയ്യാനോ സാധിക്കും. എല്ലാം പബ്ലിക് ആണെങ്കിൽ, ചെറിയ മാറ്റങ്ങൾ പോലും വലിയ പ്രശ്നങ്ങൾക്ക് കാരണമാകും.

3. ആകസ്മികമായ മാറ്റങ്ങൾ തടയുകയും ഇൻവേരിയന്റുകൾ നടപ്പിലാക്കുകയും ചെയ്യുന്നു

പബ്ലിക് രീതികളുമായി (ഗെറ്ററുകളും സെറ്ററുകളും) ചേർന്ന് സ്വകാര്യ ഫീൽഡുകൾ ഉപയോഗിച്ച് വാലിഡേഷൻ ലോജിക് ചേർക്കാൻ സാധിക്കും. ഒരു ഒബ്ജക്റ്റിന് അതിൻ്റേതായ നിയമങ്ങൾ നടപ്പിലാക്കാൻ സാധിക്കും.

            
class Circle {
  #radius;

  constructor(radius) {
    this.setRadius(radius);
  }

  // Public setter with validation
  setRadius(newRadius) {
    if (typeof newRadius !== 'number' || newRadius <= 0) {
      throw new Error('Radius must be a positive number.');
    }
    this.#radius = newRadius;
  }

  get radius() {
    return this.#radius;
  }

  get area() {
    return Math.PI * this.#radius * this.#radius;
  }
}

const c = new Circle(10);
console.log(c.area); // ~314.159

c.setRadius(20); // Works as expected
console.log(c.radius); // 20

try {
  c.setRadius(-5); // Fails due to validation
} catch (e) {
  console.error(e.message); // 'Radius must be a positive number.'
}

// The internal #radius is never set to an invalid state.
console.log(c.radius); // 20

            

              
                Copy
              
            
          

4. കോഡിന്റെ വ്യക്തതയും പരിപാലനക്ഷമതയും മെച്ചപ്പെടുത്തുന്നു

# സിന്റാക്സ് വ്യക്തമാണ്. മറ്റൊരു ഡെവലപ്പർ നിങ്ങളുടെ ക്ലാസ് വായിക്കുമ്പോൾ, അതിൻ്റെ ഉപയോഗത്തെക്കുറിച്ച് ഒരു അവ്യക്തതയും ഉണ്ടാകില്ല. ഏതൊക്കെ ഭാഗങ്ങളാണ് ഇന്റേണലായി ഉപയോഗിക്കേണ്ടതെന്നും ഏതൊക്കെയാണ് പബ്ലിക് API-യുടെ ഭാഗമെന്നും അവർക്ക് പെട്ടെന്ന് മനസ്സിലാകും. ഈ സ്വയം വിശദീകരിക്കുന്ന സ്വഭാവം കാരണം കോഡ് മനസ്സിലാക്കാനും പരിപാലിക്കാനും എളുപ്പമാണ്.

പ്രായോഗിക സാഹചര്യങ്ങളും വിപുലമായ പാറ്റേണുകളും

സ്വകാര്യ ഫീൽഡുകൾ കൂടുതൽ സങ്കീർണ്ണമായ സാഹചര്യങ്ങളിൽ എങ്ങനെ ഉപയോഗിക്കാം എന്ന് നോക്കാം.

Scenario 1: സുരക്ഷിതമായ `User` ക്ലാസ്

യൂസർ ഡാറ്റ കൈകാര്യം ചെയ്യുന്ന ഏതൊരു ആപ്ലിക്കേഷനിലും സുരക്ഷ ഒരു പ്രധാന കാര്യമാണ്. പാസ്‌വേഡ് ഹാഷ് അല്ലെങ്കിൽ വ്യക്തിഗത തിരിച്ചറിയൽ നമ്പർ പോലുള്ള സെൻസിറ്റീവ് വിവരങ്ങൾ ഒരു യൂസർ ഒബ്ജക്റ്റിൽ പബ്ലിക്കായി ആക്സസ് ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിക്കില്ല.

            
import { hash, compare } from 'some-bcrypt-library'; // Fictional library

class User {
  #passwordHash;
  #personalIdentifier;
  #lastLoginTimestamp;

  constructor(username, password, pii) {
    this.username = username; // Public username
    this.#passwordHash = hash(password); // Store only the hash, and keep it private
    this.#personalIdentifier = pii;
    this.#lastLoginTimestamp = null;
  }

  async authenticate(passwordAttempt) {
    const isMatch = await compare(passwordAttempt, this.#passwordHash);
    if (isMatch) {
      this.#lastLoginTimestamp = Date.now();
      console.log('Authentication successful.');
      return true;
    }
    console.log('Authentication failed.');
    return false;
  }

  // A public method to get non-sensitive info
  getProfileData() {
    return {
      username: this.username,
      lastLogin: this.#lastLoginTimestamp ? new Date(this.#lastLoginTimestamp) : 'Never'
    };
  }

  // No getter for passwordHash or personalIdentifier!
}

const user = new User('globaldev', 'superS3cret!', 'ID-12345');

// The sensitive data is completely inaccessible from the outside.
console.log(user.username); // 'globaldev'
console.log(user.#passwordHash); // SyntaxError!

            

              
                Copy
              
            
          

Scenario 2: ഒരു UI കോമ്പോണന്റിലെ ഇന്റേണൽ സ്റ്റേറ്റ് കൈകാര്യം ചെയ്യുന്നു

ഒരു ഇമേജ് കറൗസൽ പോലുള്ള ഒരു UI കോമ്പോണന്റ് നിങ്ങൾ ഉണ്ടാക്കുകയാണെന്ന് കരുതുക. നിലവിൽ ആക്ടീവ് ആയിട്ടുള്ള സ്ലൈഡിന്റെ ഇൻഡക്സ് പോലുള്ള ഇന്റേണൽ സ്റ്റേറ്റ് കോമ്പോണന്റ് ട്രാക്ക് ചെയ്യേണ്ടതുണ്ട്. ഈ സ്റ്റേറ്റ് കോമ്പോണന്റ് പബ്ലിക് രീതികളിലൂടെ മാത്രമേ മാറ്റം വരുത്താൻ പാടുള്ളൂ (`next()`, `prev()`, `goToSlide()`).

            
class Carousel {
  #slides;
  #currentIndex;
  #containerElement;

  constructor(containerSelector, slidesData) {
    this.#containerElement = document.querySelector(containerSelector);
    this.#slides = slidesData;
    this.#currentIndex = 0;
    this.#render();
  }

  // Private method to handle all DOM updates
  #render() {
    const currentSlide = this.#slides[this.#currentIndex];
    // Logic to update the DOM to show the current slide...
    console.log(`Rendering slide ${this.#currentIndex + 1}: ${currentSlide.title}`);
  }

  // Public API methods
  next() {
    this.#currentIndex = (this.#currentIndex + 1) % this.#slides.length;
    this.#render();
  }

  prev() {
    this.#currentIndex = (this.#currentIndex - 1 + this.#slides.length) % this.#slides.length;
    this.#render();
  }

  getCurrentSlide() {
    return this.#slides[this.#currentIndex];
  }
}

const myCarousel = new Carousel('#carousel-widget', [
  { title: 'Tokyo Skyline', image: 'tokyo.jpg' },
  { title: 'Paris at Night', image: 'paris.jpg' },
  { title: 'New York Central Park', image: 'nyc.jpg' }
]);

myCarousel.next(); // Renders slide 2
myCarousel.next(); // Renders slide 3

// You cannot mess up the component's state from the outside.
// myCarousel.#currentIndex = 10; // SyntaxError! This protects the component's integrity.

            

              
                Copy
              
            
          

സാധാരണ പ്രശ്നങ്ങളും പ്രധാന കാര്യങ്ങളും

ശക്തമായ ഒരു ഫീച്ചറാണെങ്കിലും, സ്വകാര്യ ഫീൽഡുകൾ ഉപയോഗിക്കുമ്പോൾ ശ്രദ്ധിക്കേണ്ട ചില കാര്യങ്ങളുണ്ട്.

1. സ്വകാര്യ ഫീൽഡുകൾ സിന്റാക്സുകളാണ്, പ്രോപ്പർട്ടികൾ മാത്രമല്ല

ഒരു പ്രധാന വ്യത്യാസം എന്തെന്നാൽ, ഒരു സ്വകാര്യ ഫീൽഡ് `this.#field` ഒരു സ്ട്രിംഗ് പ്രോപ്പർട്ടി `this['#field']` പോലെ അല്ല. ഡൈനാമിക് ബ്രാക്കറ്റ് നൊട്ടേഷൻ ഉപയോഗിച്ച് സ്വകാര്യ ഫീൽഡുകൾ ആക്സസ് ചെയ്യാൻ കഴിയില്ല.

            
class MyClass {
  #privateField = 42;

  getPrivateFieldValue() {
    return this.#privateField; // OK
  }

  getPrivateFieldDynamically(fieldName) {
    // return this[fieldName]; // This won't work for private fields
  }
}

const instance = new MyClass();
console.log(instance.getPrivateFieldValue()); // 42
// console.log(instance['#privateField']); // undefined

            

              
                Copy
              
            
          

2. പ്ലെയിൻ ഒബ്ജക്റ്റുകളിൽ സ്വകാര്യ ഫീൽഡുകളില്ല

ഈ ഫീച്ചർ `class` സിന്റാക്സിന് മാത്രമുള്ളതാണ്. ഒബ്ജക്റ്റ് ലിറ്ററൽ സിന്റാക്സ് ഉപയോഗിച്ച് ഉണ്ടാക്കിയ പ്ലെയിൻ JavaScript ഒബ്ജക്റ്റുകളിൽ സ്വകാര്യ ഫീൽഡുകൾ ഉണ്ടാക്കാൻ കഴിയില്ല.

3. ഇൻഹെറിറ്റൻസും സ്വകാര്യ ഫീൽഡുകളും

ഇതൊരു പ്രധാന കാര്യമാണ്: ഒരു സബ്ക്ലാസിന് അതിൻ്റെ പാരൻ്റ് ക്ലാസ്സിലെ സ്വകാര്യ ഫീൽഡുകൾ ആക്സസ് ചെയ്യാൻ കഴിയില്ല. ഇത് ശക്തമായ എൻക്യാപ്‌സുലേഷൻ ഉറപ്പാക്കുന്നു. പാരൻ്റ് ക്ലാസ്സിൻ്റെ പബ്ലിക് അല്ലെങ്കിൽ പ്രൊട്ടക്റ്റഡ് രീതികളിലൂടെ മാത്രമേ (JavaScript-ൽ `protected` കീവേഡ് ഇല്ല, പക്ഷേ ഇത് ചില രീതികളിൽ ഉപയോഗിക്കാം) ചൈൽഡ് ക്ലാസ്സിന് പാരൻ്റിൻ്റെ ഇന്റേണൽ സ്റ്റേറ്റുമായി ബന്ധപ്പെടാൻ കഴിയൂ.

            
class Vehicle {
  #fuel;

  constructor(initialFuel) {
    this.#fuel = initialFuel;
  }

  drive(kilometers) {
    const fuelNeeded = kilometers / 10; // Simple consumption model
    if (this.#fuel >= fuelNeeded) {
      this.#fuel -= fuelNeeded;
      console.log(`Driven ${kilometers} km.`);
      return true;
    }
    console.log('Not enough fuel.');
    return false;
  }
}

class Car extends Vehicle {
  constructor(initialFuel) {
    super(initialFuel);
  }

  checkFuel() {
    // This will cause an error!
    // A Car cannot directly access the #fuel of a Vehicle.
    // console.log(this.#fuel);
    // To make this work, the Vehicle class would need to provide a public `getFuel()` method.
  }
}

const myCar = new Car(50);
myCar.drive(100); // Driven 100 km.
// myCar.checkFuel(); // Would throw a SyntaxError

            

              
                Copy
              
            
          

4. ഡിബഗ്ഗിംഗും ടെസ്റ്റിംഗും

യഥാർത്ഥ സ്വകാര്യത എന്നാൽ ബ്രൗസറിൻ്റെ ഡെവലപ്പർ കൺസോളിൽ നിന്നോ അല്ലെങ്കിൽ ഒരു Node.js ഡിബഗ്ഗറിൽ നിന്നോ `instance.#field` എന്ന് ടൈപ്പ് ചെയ്ത് ഒരു സ്വകാര്യ ഫീൽഡിന്റെ വാല്യു എളുപ്പത്തിൽ പരിശോധിക്കാൻ കഴിയില്ല. ഇത് ഉദ്ദേശിച്ചുള്ള സ്വഭാവമാണെങ്കിലും, ഇത് ഡിബഗ്ഗിംഗ് കൂടുതൽ ബുദ്ധിമുട്ടാക്കും. ഇത് കുറയ്ക്കുന്നതിനുള്ള ചില വഴികൾ:

• സ്വകാര്യ ഫീൽഡുകൾ സ്കോപ്പിലുള്ള ക്ലാസ് രീതികൾക്കുള്ളിൽ ബ്രേക്ക്‌പോയിന്റുകൾ ഉപയോഗിക്കുക.
• പരിശോധനയ്ക്കായി ഡെവലപ്‌മെൻ്റ് സമയത്ത് ഒരു പബ്ലിക് ഗെറ്റർ രീതി താൽക്കാലികമായി ചേർക്കുക (ഉദാഹരണത്തിന്, `_debug_getInternalState()`).
• പബ്ലിക് API വഴി ഒബ്ജക്റ്റിൻ്റെ സ്വഭാവം പരിശോധിക്കുന്ന സമഗ്രമായ യൂണിറ്റ് ടെസ്റ്റുകൾ എഴുതുക, നിരീക്ഷിക്കാൻ കഴിയുന്ന ഫലങ്ങളെ അടിസ്ഥാനമാക്കി ഇന്റേണൽ സ്റ്റേറ്റ് ശരിയായിരിക്കണം.

ബ്രൗസറും എൻവയോൺമെൻ്റും

സ്വകാര്യ ക്ലാസ് ഫീൽഡുകൾ ഒരു ആധുനിക JavaScript ഫീച്ചറാണ്, ഇത് ECMAScript 2022-ൽ നിലവിൽ വന്നു. എല്ലാ പ്രധാന ബ്രൗസറുകളിലും (Chrome, Firefox, Safari, Edge) Node.js-ൻ്റെ പുതിയ പതിപ്പുകളിലും (സ്വകാര്യ രീതികൾക്ക് v14.6.0+, സ്വകാര്യ ഫീൽഡുകൾക്ക് v12.0.0+) ഇത് സപ്പോർട്ട് ചെയ്യുന്നു.

പഴയ ബ്രൗസറുകളെയോ എൻവയോൺമെൻ്റുകളെയോ സപ്പോർട്ട് ചെയ്യേണ്ട പ്രോജക്റ്റുകൾക്ക്, Babel പോലുള്ള ഒരു ട്രാൻസ്പൈലർ ആവശ്യമാണ്. `@babel/plugin-proposal-class-properties` , `@babel/plugin-proposal-private-methods` പ്ലഗിനുകൾ ഉപയോഗിച്ച് Babel, ആധുനികമായ `#` സിന്റാക്സിനെ പഴയ JavaScript കോഡിലേക്ക് മാറ്റും. ഇത് സ്വകാര്യതയെ അനുകരിക്കാൻ `WeakMap` ഉപയോഗിക്കുന്നു, ഇത് പഴയ പതിപ്പുകളിലും ഉപയോഗിക്കാൻ സഹായിക്കുന്നു.

Can I Use... അല്ലെങ്കിൽ MDN Web Docs പോലുള്ള വെബ്സൈറ്റുകളിൽ compatibility-യെക്കുറിച്ച് പരിശോധിക്കുക.

ഉപസംഹാരം: മികച്ച കോഡിംഗിനായി ആധുനിക JavaScript ഉപയോഗിക്കുക

JavaScript സ്വകാര്യ ഫീൽഡുകൾ എന്നത് ഒരു സിന്റാക്റ്റിക് ഷുഗർ മാത്രമല്ല; സുരക്ഷിതവും, കൂടുതൽ ഘടനാപരവും, പ്രൊഫഷണലുമായ ഒബ്ജക്റ്റ് ഓറിയന്റഡ് കോഡ് എഴുതാൻ ഡെവലപ്പർമാരെ സഹായിക്കുന്ന ഭാഷയുടെ പരിണാമത്തിലെ ഒരു പ്രധാന മുന്നേറ്റമാണിത്. ട്രൂ എൻക്യാപ്‌സുലേഷനുള്ള ഒരു മെക്കാനിസം നൽകുന്നതിലൂടെ, പഴയ രീതികളുടെ അവ്യക്തതയും ക്ലോഷർ അടിസ്ഥാനമാക്കിയുള്ള പാറ്റേണുകളുടെ സങ്കീർണ്ണതയും `#` സിന്റാക്സ് ഇല്ലാതാക്കുന്നു.

ഈ കാര്യങ്ങൾ പ്രധാനമാണ്:

• യഥാർത്ഥ സ്വകാര്യത: ക്ലാസിന് പുറത്ത് നിന്ന് ആക്സസ് ചെയ്യാൻ കഴിയാത്ത ക്ലാസ് അംഗങ്ങളെ `#` പ്രിഫിക്സ് ഉണ്ടാക്കുന്നു, ഇത് JavaScript എഞ്ചിൻ തന്നെ ഉറപ്പാക്കുന്നു.
• ശക്തമായ API-കൾ: ഇന്റേണൽ ഇംപ്ലിമെൻ്റേഷൻ മാറ്റാനുള്ള സൗകര്യത്തോടൊപ്പം സ്ഥിരതയുള്ള പബ്ലിക് ഇൻ്റർഫേസുകൾ നിർമ്മിക്കാൻ എൻക്യാപ്‌സുലേഷൻ നിങ്ങളെ അനുവദിക്കുന്നു.
• മെച്ചപ്പെട്ട കോഡ് ഇന്റഗ്രിറ്റി: ഒബ്ജക്റ്റിൻ്റെ അവസ്ഥയിലേക്കുള്ള ആക്സസ് നിയന്ത്രിക്കുന്നതിലൂടെ, തെറ്റായ മാറ്റങ്ങൾ തടയാൻ സാധിക്കും, ഇത് ബഗുകൾ കുറയ്ക്കുന്നു.
• വർദ്ധിപ്പിച്ച വ്യക്തത: സിന്റാക്സ് നിങ്ങളുടെ ഉദ്ദേശ്യം വ്യക്തമായി പറയുന്നു, ഇത് ക്ലാസുകൾ മനസ്സിലാക്കാനും പരിപാലിക്കാനും എളുപ്പമാക്കുന്നു.

നിങ്ങളുടെ അടുത്ത JavaScript പ്രോജക്റ്റ് ആരംഭിക്കുമ്പോളോ നിലവിലുള്ളവ മാറ്റിയെഴുതുമ്പോളോ, സ്വകാര്യ ഫീൽഡുകൾ ഉപയോഗിക്കാൻ ശ്രമിക്കുക. നിങ്ങളുടെ ഡെവലപ്പർ ടൂൾകിറ്റിലെ ശക്തമായ ഒരു ടൂളാണ് ഇത്, ഇത് കൂടുതൽ സുരക്ഷിതവും പരിപാലിക്കാൻ എളുപ്പമുള്ളതുമായ ആപ്ലിക്കേഷനുകൾ ഉണ്ടാക്കാൻ സഹായിക്കും.